package designModel;
// 策略（Strategy）模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。 ☆☆☆☆☆
// 鸭子模式...
public class Strategy {
    public static void main(String[] args) {

        DuckA duckA = new DuckA();
        duckA.a();

        DuckB duckb = new DuckB();
        duckb.a();
    }
}

abstract class Duck{
    //ABehavior
    ABehavior aBehavior;


    public abstract void display();

    public void a(){
        if (aBehavior!=null){
            aBehavior.aBehavior();
        }
    }
    public void b(){
        System.out.println("b");
    }
    public void c(){
        System.out.println("c");
    }

}
class DuckA extends Duck{

    // 在构造器里面初始化鸭子的aBehavior能力
    public DuckA() {
        aBehavior = new GoodABehavior();
    }

    @Override
    public void display() {
        System.out.println("DuckA");
    }
}
// 鸭子  与鸭子的不同行为 分离
class DuckB extends Duck{

    public DuckB() {
        aBehavior = new BadABehavior();
    }

    @Override
    public void display() {
        System.out.println("DuckB");
    }
}
class DuckC extends Duck{

    public DuckC() {
        aBehavior = new BadABehavior();
    }

    @Override
    public void display() {
        System.out.println("DuckB");
    }
}


// 不同的鴨子 相同的行为但是表现可能不太一样 (策略可能不太一样，且有可能会比较多)
interface ABehavior{
    void aBehavior();
}
interface BBehavior{
    void bBehavior();
}
interface CBehavior{
    void cBehavior();
}

class GoodABehavior implements ABehavior{
    @Override
    public void aBehavior() {
        System.out.println("A表现好的");
    }
}
class BadABehavior implements ABehavior{
    @Override
    public void aBehavior() {
        System.out.println("A表现不好的");

    }
}

class NOTGoodBadABehavior implements ABehavior{
    @Override
    public void aBehavior() {
        System.out.println("A表现不好不坏的");

    }
}


